// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov  Date: 2007-9-15 18:54:34

// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   vm.java

package com.zelix;

import java.util.*;

// Referenced classes of package com.zelix:
//            rb, wg, it, sb, 
//            tb, wb, ld, md, 
//            qd, kd, ie, td, 
//            ud, vd, zd, le, 
//            fe, ss, ks, is, 
//            vs, rs, ys, qm, 
//            rm, i5, tm, um, 
//            wm, xm, ym, zm, 
//            an, bn, cn, e1, 
//            hn, jn, kn, ub, 
//            ln, mn, qn, rn, 
//            sn, vn, un, wn, 
//            yn, zn, ju, mu, 
//            du, kt, eu, lu, 
//            iu, ou, pu, s6, 
//            qu, fv, lx, px, 
//            sx, ux, fy, wu, 
//            jy, py, qy, sy, 
//            e6, vh, lt, gs, 
//            yg, au, lm, t6, 
//            tn

public final class vm
{

    static final ux a;
    private Vector b;
    private eu c[];
    private int d;
    private int e;
    private bn f;
    private Vector g;
    private Vector h;
    private qy i;
    private wn j[];
    private sn k[];
    private Vector l;
    private int m;
    private um n;
    private wg t;
    private fy o;
    private String p;
    private du q;
    private bn r[];
    private boolean s;
    private static String z[];

    public vm(Vector vector, eu aeu[], int i1, int j1, Vector vector1, boolean flag, boolean flag1, 
            um um1, wg wg1, du du1)
        throws ub, tb, sb {
        super();

        int k1;
        boolean flag2;
        boolean flag3;
        flag3 = lt.y;
        flag2 = wn.C;
        g = new Vector();
        h = new Vector();
        q = du1;
        p = du1.v();
        n = um1;
        t = wg1;
        b = vector;
        c = aeu;
        d = i1;
        j = wn.a(i1);
        k1 = 0;
        if (!flag)
            j[k1++] = wn.a("L" + du1.j() + ";", flag1 ^ true);
        if (vector1 != null) {
            int i4 = vh.e;
            vh.e = ++i4;
            for (int l1 = 0; l1 < vector1.size(); l1++) {

                String s1 = (String) vector1.elementAt(l1);
                j[k1++] = wn.c(s1);
                e++;
                if (s1.equals("J") || s1.equals("D")) {
                    j[k1++] = wn.o;
                    e++;
                }
            }

        }


        int i2;
        Hashtable hashtable;
        qy qy1;
        int j2;
        int l1 = 0;
        i2 = vector.size();
        hashtable = new Hashtable();
        qy1 = new qy();
        j2 = 0;
        for (; j2 < i2; j2++) {
            kd kd1 = (kd) vector.elementAt(j2);
            if (kd1 instanceof ie) {
                ((ie) kd1).a(hashtable, qy1, h);
                if (!kd.k(kd1.f()))
                    continue; /* Loop/switch isn't completed */
                s = true;
                if (!flag2)
                    continue; /* Loop/switch isn't completed */
            }
            if (kd1 instanceof td)
                ((td) kd1).n(j2);
        }

        xm axm[];
        int l2;
        int i3;
        int k2 = aeu.length;
        if (aeu != null) {
            axm = new xm[aeu.length];
            i = new qy(aeu.length);
            l2 = 0;
            for (i3 = 0; i3 < aeu.length; i3++) {
                td td1;
                td td2;
                td td3;
                bn bn2;
                label0:
                {
                    td1 = aeu[i3].b(0);
                    td2 = aeu[i3].b(1);
                    td3 = aeu[i3].b(2);
                    bn2 = null;
                    if ((bn2 = (bn) hashtable.get(td3)) == null) {
                        bn2 = new bn();
                        h.addElement(bn2);
                        hashtable.put(td3, bn2);
                        bn2.a(z[21] + l2++);
                        g.addElement(bn2);
                        if (!flag2)
                            break label0;
                    }
                    if (!i.b(bn2) && !g.contains(bn2)) {
                        g.addElement(bn2);
                        bn2.a(z[21] + l2++);
                    }
                }
                axm[i3] = new xm(this, i3, td1.a(), td2.a(), td3.a(), aeu[i3].q(), aeu[i3].a(), bn2, aeu[i3]);
                i.b(bn2, axm[i3]);
            }
        }

        axm = new xm[0];
        Hashtable hashtable1;
        bn bn1;
        jy jy1;
        int j3;
        hashtable1 = new Hashtable();
        kd kd2 = (kd) vector.elementAt(0);
        if (kd2 instanceof td)
            f = (bn) hashtable.get(kd2);
        if (f == null) {
            f = new bn();
            h.addElement(f);
        }
        if (kd2 instanceof td)
            hashtable1.put(kd2, f);
        f.a(z[20]);
        bn1 = f;
        bn1.c(0);
        jy1 = new jy();
        for (j3 = 0; j3 < i2; j3++) {
            kd kd3;
            int k3;
            Vector vector2;
            int l3;
            kd3 = (kd) vector.elementAt(j3);
            k3 = kd3.f();
            if ((kd3 instanceof ie)) {
                bn1.b(j3);
                vector2 = qy1.d(kd3);
                for (l3 = 0; l3 < vector2.size(); l3++) {
                    bn1.d((bn) vector2.elementAt(l3));
                }
                bn bn5;
                if (j3 + 1 >= i2)
                    continue; /* Loop/switch isn't completed */
                bn5 = null;
                kd kd6 = (kd) vector.elementAt(j3 + 1);
                if (!(kd6 instanceof td) || (bn5 = (bn) hashtable.get(kd6)) == null) {
                    bn5 = new bn();
                    h.addElement(bn5);
                }
                if (bn5.h() == null)
                    bn5.a(z[19] + l1++);
                bn5.c(j3 + 1);
                if (kd3.b()) {
                    bn1.d(bn5);
                } else if (kd.k(k3)) {
                    bn1.f(bn5);
                    bn bn7 = (bn) vector2.elementAt(0);
                    bn7.b(bn1);
                    jy1.put(bn7, bn7);
                }
                bn1 = bn5;
            } else if (kd3 instanceof td) {
                if (j3 <= 0)
                    continue; /* Loop/switch isn't completed */
                bn bn3 = (bn) hashtable.get(kd3);
                if (bn3 != null && bn1 != bn3) {
                    kd kd4 = (kd) vector.elementAt(j3 - 1);
                    bn1.b(j3 - 1);
                    bn3.c(j3);
                    if (bn3.h() == null)
                        bn3.a(z[19] + l1++);
                    if (kd4.b())
                        bn1.d(bn3);
                    bn1 = bn3;
                }
                hashtable1.put(kd3, bn1);
                if (!flag2)
                    continue; /* Loop/switch isn't completed */
            }
            if (kd3.c()) {
                bn1.b(j3);
                if (j3 + 1 < i2) {
                    bn bn4 = null;
                    kd kd5 = (kd) vector.elementAt(j3 + 1);
                    if (!(kd5 instanceof td) || (bn4 = (bn) hashtable.get(kd5)) == null) {
                        bn4 = new bn();
                        h.addElement(bn4);
                    }
                    if (bn4.h() == null)
                        bn4.a(z[19] + l1++);
                    bn4.c(j3 + 1);
                    bn1 = bn4;
                }
            }
        }
        xm axm1[][];
        fy fy1;
        Iterator iterator;
        Collections.sort(g);
        Collections.sort(h);
        axm1 = new xm[i2][];
        fy1 = null;
        if (g.size() > 0) {
            fy1 = new fy(g.size());
            a(fy1, axm1, axm);
        }
        ArrayList arraylist = a(jy1);
        iterator = arraylist.iterator();
        while (iterator.hasNext()) {
            Iterator iterator1;
            bn bn6 = (bn) iterator.next();
            a(bn6, bn6, new HashSet(13));
            if (bn6.n())
                continue; /* Loop/switch isn't completed */
            List list = bn6.f();
            iterator1 = list.iterator();
            while (iterator1.hasNext()) {
                bn bn8 = (bn) iterator1.next();
                bn8.f(null);
            }
        }

        a(fy1);
        l = e();
        m = d();
        a(um1, axm1, false, false);
        if (flag3) {
            int j4 = gs.b;
            gs.b = ++j4;
        }
        return;
    }

    static Vector a(vm vm1)
    {
        return vm1.b;
    }

    static sn[] b(vm vm1)
    {
        return vm1.k;
    }

    static void a(vm vm1, ArrayList arraylist, bn bn1, int i1, int j1, HashSet hashset)
    {
        vm1.a(arraylist, bn1, i1, j1, hashset);
    }

    private void a(bn bn1, fy fy1, ArrayList arraylist) {
        Hashtable hashtable;
        boolean flag;
        flag = wn.C;
        arraylist.add(bn1);
        hashtable = fy1.b(bn1);
        if (hashtable != null) {
            Enumeration enumeration = hashtable.keys();
            while (enumeration.hasMoreElements()) {
                a((bn) enumeration.nextElement(), fy1, arraylist);
            }
        }
    }

    public rn a(int i1, ss ss1, qm qm1, sy sy1, sy sy2, sy sy3, Map map, 
            HashMap hashmap, HashMap hashmap1, HashMap hashmap2, HashMap hashmap3, yg yg, Map map1)
    {
        rn rn1;
        bn bn1;
        int j1;
        boolean flag;
        Iterator iterator;
        boolean flag1;
        flag1 = wn.C;
        rn1 = new rn(qm1);
        zd zd1 = (zd)b.get(i1);
        bn1 = a(i1);
        sn sn1 = k[i1];
        if(sn1 == null)
        {
            HashSet hashset = new HashSet(5);
            hashset.add(new yn(zd1, z[57]));
            rn1.a(hashset);
            return rn1;
        }
        j1 = sn1.g();
        flag = q.t().D();
        if(qm1.b())
        {
            HashSet hashset1 = new HashSet(5);
            hashset1.add(new yn(zd1, z[56]));
            rn1.a(hashset1);
            if(!flag1)
                break MISSING_BLOCK_LABEL_382;
        }
        iterator = qm1.d().iterator();
        if(!flag1) goto _L2; else goto _L1
_L1:
        rm rm1 = (rm)iterator.next();
        int l1 = j1 + qm1.e() + rm1.a();
        HashSet hashset3 = new HashSet(13);
        byte byte0 = ((byte)(rm1.e() ? 2 : 1));
        zm zm2 = new zm(this, hashset3, rm1.b(), byte0, sy1, sy2, sy3, n, yg, map, flag, hashmap, hashmap1, hashmap2, hashmap3, map1);
        a(zm2, bn1, i1, l1);
        rn1.a(hashset3);
_L2:
        if(iterator.hasNext()) goto _L1; else goto _L3
_L3:
        if(qm1.a())
        {
            int k1 = j1 - 1;
            HashSet hashset2 = new HashSet(13);
            zm zm1 = new zm(this, hashset2, false, 2, sy1, sy2, sy3, n, yg, map, flag, hashmap, hashmap1, hashmap2, hashmap3, map1);
            a(zm1, bn1, i1, k1);
            rn1.a(hashset2);
        }
        return rn1;
    }

    private void a(zm zm1, bn bn1, int i1)
    {
        zd zd1;
        int j1;
        wm wm1;
        hn hn1;
        int k1;
        boolean flag;
        flag = wn.C;
        zd1 = (zd)b.get(i1);
        if(i1 <= bn1.m())
            break MISSING_BLOCK_LABEL_407;
label0:
        {
            kd kd1 = (kd)b.get(i1 - 1);
            j1 = 0;
            switch(kd1.f())
            {
            case 3: // '\003'
                j1 = 0;
                if(!flag)
                    break label0;
                // fall through

            case 4: // '\004'
                j1 = 1;
                if(!flag)
                    break label0;
                // fall through

            case 5: // '\005'
                j1 = 2;
                if(!flag)
                    break label0;
                // fall through

            case 6: // '\006'
                j1 = 3;
                if(!flag)
                    break label0;
                // fall through

            case 7: // '\007'
                j1 = 4;
                if(!flag)
                    break label0;
                // fall through

            case 8: // '\b'
                j1 = 5;
                if(!flag)
                    break label0;
                // fall through

            case 16: // '\020'
                j1 = ((ld)kd1).a();
                if(!flag)
                    break label0;
                // fall through

            case 9: // '\t'
            case 10: // '\n'
            case 11: // '\013'
            case 12: // '\f'
            case 13: // '\r'
            case 14: // '\016'
            case 15: // '\017'
            default:
                zm1.b.add(new yn(zd1, z[31] + kd1 + " " + zm1.l));
                return;
            }
        }
        sn sn1 = k[i1];
        if(j1 <= 0)
            break MISSING_BLOCK_LABEL_377;
        wm1 = g();
        a(zm1, ((an) (wm1)), bn1, i1 + 1, sn1.c().length - 1);
        hn1 = new hn(j1, wm1.a());
        k1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        HashSet hashset = wm1.a(k1);
        if(hashset == null)
        {
            hashset = new HashSet(3);
            hashset.add(new yn(zd1, wm1.a().toString()));
        }
        hn1.a(k1, hashset);
        k1++;
_L2:
        if(k1 < j1) goto _L1; else goto _L3
_L3:
        zm1.b.add(hn1);
        if(!flag)
            break MISSING_BLOCK_LABEL_447;
        zm1.b.add(new hn(j1, new ArrayList(0)));
        if(!flag)
            break MISSING_BLOCK_LABEL_447;
        zm1.b.add(new yn(zd1, z[32] + zm1.l));
    }

    private void a(fy fy1, xm axm[][], xm axm1[])
        throws wb
    {
        ArrayList arraylist;
        int i1;
        int j1;
        boolean flag;
        flag = wn.C;
        arraylist = new ArrayList();
        i1 = h.size();
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn1;
        int k1;
        int l1;
        int i2;
        bn1 = (bn)h.get(j1);
        k1 = bn1.m();
        l1 = bn1.d();
        i2 = k1;
        if(!flag) goto _L4; else goto _L3
_L3:
        kd kd1;
        xm axm2[];
        int j2;
        kd1 = (kd)b.get(i2);
        axm2 = a(i2, axm1);
        j2 = 0;
        if(!flag) goto _L6; else goto _L5
_L5:
        Object obj = fy1.b(axm2[j2].f, bn1, bn1);
        if(obj == null)
            bn1.a(axm2[j2].f);
        if(i2 == axm2[j2].b || i2 == k1 || kd1.j() || !arraylist.contains(axm2[j2]))
            arraylist.add(axm2[j2]);
        j2++;
_L6:
        if(j2 < axm2.length) goto _L5; else goto _L7
_L7:
        if(arraylist.size() > 0)
        {
            xm axm3[] = new xm[arraylist.size()];
            axm[i2] = (xm[])arraylist.toArray(axm3);
            arraylist.clear();
        }
        i2++;
_L4:
        if(i2 <= l1) goto _L3; else goto _L8
_L8:
        j1++;
_L2:
        if(j1 >= i1)
            return;
        if(true) goto _L1; else goto _L9
_L9:
    }

    private void b(zm zm1, bn bn1, int i1)
    {
        zd zd1;
        vs vs1;
        lu lu1;
        po po;
        HashSet hashset;
        qy qy1;
        boolean flag;
        flag = wn.C;
        zd1 = (zd)b.get(i1);
        vs1 = (vs)zd1.p();
        lu1 = (lu)vs1.o();
        if(lu1 == null)
            break MISSING_BLOCK_LABEL_319;
        po = lu1.M();
        hashset = null;
        if(zm1.n.containsKey(po))
        {
            hashset = (HashSet)zm1.n.get(po);
            break MISSING_BLOCK_LABEL_299;
        }
        hashset = new HashSet(13);
        qy1 = zm1.e.b(po);
        if(qy1 == null) goto _L2; else goto _L1
_L1:
        Enumeration enumeration = qy1.e();
        if(!flag) goto _L4; else goto _L3
_L3:
        du du1;
        Vector vector;
        du1 = (du)enumeration.nextElement();
        vector = qy1.d(du1);
        HashSet hashset1;
        Iterator iterator;
        vm vm1 = du1.a(zm1.r, zm1.g, t);
        hashset1 = vm1.a(zm1, lu1, vector);
        iterator = hashset1.iterator();
        if(!flag) goto _L6; else goto _L5
_L5:
        if(iterator.next() instanceof ln)
            iterator.remove();
_L6:
        if(iterator.hasNext()) goto _L5; else goto _L7
_L7:
        hashset.addAll(hashset1);
        continue; /* Loop/switch isn't completed */
        rb rb1;
        rb1;
        zm1.b.add(new yn(zd1, z[13] + rb1.getMessage() + "'"));
_L4:
        if(enumeration.hasMoreElements()) goto _L3; else goto _L2
_L2:
        zm1.n.put(po, hashset);
        if(hashset == null)
            break MISSING_BLOCK_LABEL_775;
        zm1.b.addAll(hashset);
        if(!flag)
            break MISSING_BLOCK_LABEL_775;
        String s1 = vs1.b();
        if(vs1.n().equals(z[8]))
        {
            if(s1.equals(z[14]))
            {
                zm1.b.add(new cn("I"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[11]))
            {
                zm1.b.add(new cn("B"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[18]))
            {
                zm1.b.add(new cn("C"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[15]))
            {
                zm1.b.add(new cn("S"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[9]))
            {
                zm1.b.add(new cn("J"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[12]))
            {
                zm1.b.add(new cn("F"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[17]))
            {
                zm1.b.add(new cn("D"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[7]))
            {
                zm1.b.add(new cn("Z"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            if(s1.equals(z[16]))
            {
                zm1.b.add(new cn("V"));
                if(!flag)
                    break MISSING_BLOCK_LABEL_775;
            }
            zm1.b.add(new yn(zd1, z[10] + s1 + "." + z[8]));
            if(!flag)
                break MISSING_BLOCK_LABEL_775;
        }
        zm1.b.add(new yn(zd1, z[10] + s1 + "." + vs1.n()));
    }

    private void c(zm zm1, bn bn1, int i1)
    {
        zd zd1;
        ss ss1;
        boolean flag;
        flag = wn.C;
        zd1 = (zd)b.get(i1);
        ss1 = (ss)zd1.p();
        zm1.l;
        JVM INSTR tableswitch 1 4: default 1977
    //                   1 64
    //                   2 438
    //                   3 1363
    //                   4 1914;
           goto _L1 _L2 _L3 _L4 _L5
_L1:
        break; /* Loop/switch isn't completed */
_L2:
        if(c(ss1, zm1.h))
        {
            if(zm1.s)
            {
                zm1.b.add(new yn(zd1, z[43]));
                if(!flag)
                    break; /* Loop/switch isn't completed */
            }
            HashSet hashset = new HashSet(13);
            HashSet hashset2 = zm1.a(hashset);
            int j1 = k[i1].g();
            a(zm1, bn1, i1, j1);
            HashSet hashset5 = new HashSet(13);
            zm1.a(hashset5);
            a(zm1, bn1, i1, j1 + 1);
            HashSet hashset7 = new HashSet(13);
            zm1.a(hashset7);
            j1--;
            a(zm1, bn1, i1, j1);
            hashset2.add(new qn(hashset, hashset5, hashset7));
            zm1.a(hashset2);
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        if(b(ss1, zm1.h))
        {
            if(zm1.s)
            {
                zm1.b.add(new yn(zd1, z[43]));
                if(!flag)
                    break; /* Loop/switch isn't completed */
            }
            HashSet hashset1 = new HashSet(13);
            HashSet hashset3 = zm1.a(hashset1);
            int k1 = k[i1].g();
            a(zm1, bn1, i1, k1);
            HashSet hashset6 = new HashSet(13);
            zm1.a(hashset6);
            k1--;
            a(zm1, bn1, i1, k1);
            hashset3.add(new qn(hashset1, hashset6));
            zm1.a(hashset3);
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        zm1.b.add(new yn(zd1, z[47] + zm1.l));
        if(!flag)
            break; /* Loop/switch isn't completed */
_L3:
        Object obj;
        if(zm1.i.containsKey(ss1))
        {
            zm1.b.add(new mn(i1, q));
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        obj = (ou)ss1.o();
        if(obj == null) goto _L7; else goto _L6
_L6:
        Object obj1;
        lp lp = ((mu) (obj)).P();
        obj1 = null;
        if(zm1.m.containsKey(lp))
        {
            obj1 = (zn)zm1.m.get(lp);
        } else
        {
            du du1 = ((ou) (obj)).X();
            if(du1 != null)
                try
                {
                    vm vm1 = du1.a(zm1.r, zm1.g, t);
                    obj1 = vm1.a(zm1);
                    zm1.m.put(lp, obj1);
                }
                catch(rb rb1)
                {
                    zm1.b.add(new yn(zd1, z[13] + rb1.getMessage() + z[38] + ((kt) (obj)).j() + "." + ((mu) (obj)).u()));
                }
            else
                zm1.m.put(lp, null);
        }
        if(obj1 == null) goto _L9; else goto _L8
_L8:
        hn hn1;
        if(((zn) (obj1)).i())
        {
            zm1.b.add(new un(((zn) (obj1)).e()));
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        if(((zn) (obj1)).h())
        {
            int i2 = ((zn) (obj1)).d();
            int k2 = k[i1].g() + ((ou) (obj)).cb() + ((ou) (obj)).d(i2);
            zm zm2 = new zm(this, zm1, 1);
            a(zm2, bn1, i1, k2);
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        if(((zn) (obj1)).f())
        {
            zm1.b.add(new yn(zd1, ((zn) (obj1)).b() + z[45] + zd1.p().h()));
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        if(!((zn) (obj1)).g())
            break; /* Loop/switch isn't completed */
        hn1 = ((zn) (obj1)).c();
        if(!hn1.k()) goto _L11; else goto _L10
_L10:
        Object obj2;
        int l2;
        obj2 = hn1.g();
        l2 = 0;
        if(!flag) goto _L13; else goto _L12
_L12:
        kn kn2 = (kn)((ArrayList) (obj2)).get(l2);
        if(kn2 instanceof jn)
        {
            jn jn2 = (jn)kn2;
            if(jn2.g() == ((zn) (obj1)).a())
            {
                int j3 = jn2.h();
                int k3 = k[i1].g() + ((ou) (obj)).cb() + ((ou) (obj)).d(j3);
                zm zm4 = new zm(this, zm1, 1);
                a(zm4, bn1, i1, k3);
                if(!flag)
                    continue; /* Loop/switch isn't completed */
            }
            zm1.b.add(new yn(zd1, z[44] + jn2.h() + z[39] + jn2.g().t().fb() + z[45] + zd1.p().h()));
            if(!flag)
                continue; /* Loop/switch isn't completed */
        }
        zm1.b.add(kn2);
        l2++;
_L13:
        if(l2 < ((ArrayList) (obj2)).size()) goto _L12; else goto _L14
_L14:
        if(!flag)
            break; /* Loop/switch isn't completed */
_L11:
        zm1.b.add(new yn(zd1, z[49] + zd1.p().h()));
        if(!flag)
            break; /* Loop/switch isn't completed */
_L9:
        zm1.b.add(new yn(zd1, z[41] + zm1.l + z[45] + zd1.p().h()));
        if(!flag)
            break; /* Loop/switch isn't completed */
_L7:
        if(ss1.b().equals(z[40]) && ss1.s().equals(z[50]) && i1 > bn1.m())
        {
            sn sn1 = k[i1 - 1];
            obj1 = sn1.c()[k[i1].g() - 1].d();
            obj1 = um.a(((String) (obj1)));
            zm1.b.add(new tm(zd1, ((String) (obj1))));
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        zm1.b.add(new yn(zd1, z[42] + zm1.l));
        if(!flag)
            break; /* Loop/switch isn't completed */
_L4:
        obj = ss1.x();
        if(obj == null) goto _L16; else goto _L15
_L15:
        List list;
        int l1;
        list = ((qm) (obj)).d();
        l1 = 0;
        if(!flag) goto _L18; else goto _L17
_L17:
        rm rm1 = (rm)list.get(l1);
        if(!rm1.c() && !rm1.d())
            continue; /* Loop/switch isn't completed */
        obj2 = k[i1];
        int i3 = ((sn) (obj2)).g() + ((qm) (obj)).e() + rm1.a();
        zm zm3 = new zm(this, zm1, 4, zm1.q);
        a(zm3, bn1, i1, i3);
        if(!flag)
            break; /* Loop/switch isn't completed */
        l1++;
_L18:
        if(l1 < list.size()) goto _L17; else goto _L19
_L19:
        if(!flag)
            break; /* Loop/switch isn't completed */
_L16:
        if(!a(ss1, zm1.h)) goto _L21; else goto _L20
_L20:
        HashSet hashset4 = new HashSet(13);
        l1 = zm1.a(hashset4);
        int j2 = k[i1].g() - 1;
        a(zm1, bn1, i1, j2);
        zm1.a(l1);
        if(hashset4.size() == 0)
        {
            l1.add(new yn(zd1, z[48] + ss1.h() + z[37]));
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        obj2 = hashset4.iterator();
        if(!flag) goto _L23; else goto _L22
_L22:
        kn kn1 = (kn)((Iterator) (obj2)).next();
        if(!(kn1 instanceof jn)) goto _L25; else goto _L24
_L24:
        Iterator iterator;
        jn jn1 = (jn)kn1;
        HashSet hashset8 = new HashSet(13);
        l1 = zm1.a(hashset8);
        a(zm1, jn1.h());
        zm1.a(l1);
        iterator = hashset8.iterator();
        if(!flag) goto _L27; else goto _L26
_L26:
        kn kn3 = (kn)iterator.next();
        if(kn3 instanceof un)
        {
            l1.add(new vn(((un)kn3).g()));
            if(!flag)
                continue; /* Loop/switch isn't completed */
        }
        if(kn3 instanceof yn)
            l1.add(kn1);
_L27:
        if(iterator.hasNext()) goto _L26; else goto _L28
_L28:
        if(!flag)
            continue; /* Loop/switch isn't completed */
_L25:
        if(kn1 instanceof un)
        {
            l1.add(new vn(((un)kn1).g()));
            if(!flag)
                continue; /* Loop/switch isn't completed */
        }
        if(kn1 instanceof yn)
            l1.add(kn1);
_L23:
        if(((Iterator) (obj2)).hasNext()) goto _L22; else goto _L29
_L29:
        if(!flag)
            break; /* Loop/switch isn't completed */
_L21:
        zm1.b.add(new yn(zd1, z[46] + zd1.p().h() + z[45] + zm1.l));
        if(!flag)
            break; /* Loop/switch isn't completed */
_L5:
        zm1.b.add(new yn(zd1, z[46] + zd1.p().h() + z[45] + zm1.l));
    }

    private void d(zm zm1, bn bn1, int i1)
    {
label0:
        {
            zd zd1 = (zd)b.get(i1);
            ks ks1 = (ks)zd1.p();
            String s1 = ks1.b();
            if(s1.equals(z[1]))
            {
                sn sn1 = k[i1];
                ym ym1 = l();
                a(zm1, ym1, bn1, i1 + 1, sn1.c().length - 1);
                HashSet hashset = ym1.a();
                if(hashset.size() == 0)
                    hashset.add(new yn(zd1, z[2]));
                zm1.b.addAll(hashset);
                if(!wn.C)
                    break label0;
            }
            zm1.b.add(new yn(zd1, z[3] + s1));
        }
    }

    private void a(um um1, xm axm[][], boolean flag, boolean flag1)
        throws ub, tb, sb
    {
        TreeSet treeset;
        TreeSet treeset1;
        e6 e6_1;
        fy fy1;
        HashSet hashset;
        HashSet hashset1;
        boolean flag3;
        flag3 = wn.C;
        int i1 = b.size();
        k = new sn[i1];
        sn sn1 = new sn(j);
        kd kd1 = (kd)b.get(0);
        k[0] = kd1.a(sn1, flag, flag1, um1);
        treeset = new TreeSet();
        treeset1 = new TreeSet();
        e6_1 = new e6();
        treeset.add(a.a(0));
        fy1 = new fy();
        hashset = null;
        hashset1 = null;
_L12:
        Integer integer;
        int j1;
        kd kd2;
        int k1;
        Iterator iterator;
label0:
        {
            if(!treeset.isEmpty())
            {
                integer = (Integer)treeset.first();
                j1 = integer.intValue();
                treeset.remove(integer);
                if(!flag3)
                    break label0;
            }
            if(!treeset1.isEmpty())
            {
                integer = (Integer)treeset1.first();
                j1 = integer.intValue();
                treeset1.remove(integer);
                if(!flag3)
                    break label0;
            }
            integer = (Integer)e6_1.c();
            j1 = integer.intValue();
        }
        kd2 = (kd)b.get(j1);
        k1 = kd2.f();
        if(!(kd2 instanceof qd))
            break MISSING_BLOCK_LABEL_314;
        List list = ((qd)kd2).p();
        iterator = list.iterator();
        if(!flag3) goto _L2; else goto _L1
_L1:
        td td2 = (td)iterator.next();
        int k2 = td2.a();
        a(j1, k2, treeset, flag, flag1);
_L2:
        if(iterator.hasNext()) goto _L1; else goto _L3
_L3:
        if(!flag3)
            break MISSING_BLOCK_LABEL_360;
        if((kd2 instanceof md) && !kd.k(k1))
        {
            td td1 = ((md)kd2).q();
            int l1 = td1.a();
            a(j1, l1, treeset, flag, flag1);
        }
        xm axm1[];
        if(kd2.b())
        {
            if(k1 == 169 || k1 == 196 && ((fe)kd2).a() == 169)
                fy1.c(kd2);
            a(j1, j1 + 1, treeset, flag, flag1);
        }
        axm1 = axm[j1];
        if(axm1 == null) goto _L5; else goto _L4
_L4:
        int i2 = 0;
        if(!flag3) goto _L7; else goto _L6
_L6:
        int j2;
        sn sn3;
label1:
        {
            j2 = axm1[i2].d;
            e1 e1_1 = k[j1].e();
            e1 e1_2 = null;
            if(k[j2] != null)
                e1_2 = k[j2].e();
            if(e1_1 == null && e1_2 == null || e1_1 != null && e1_2 != null && e1_1.a(e1_2))
            {
                sn3 = k[j1];
                if(!flag3)
                    break label1;
            }
            if(e1_1 != null && e1_2 != null && !e1_1.a(e1_2))
            {
                sn3 = sn.a(um1, k[j1], k[j2].f(), e1_2);
                if(!flag3)
                    break label1;
            }
            if(e1_1 != null && e1_2 == null)
            {
                if(k[j2] != null)
                {
                    sn3 = sn.a(um1, k[j1], k[j2].f(), e1_2);
                    if(!flag3)
                        break label1;
                }
                sn3 = k[j1];
                if(!flag3)
                    break label1;
            }
            throw new ub(z[27] + p + z[36]);
        }
        sn sn5 = new sn(axm1[i2].e, sn3.f(), sn3.e());
        kd kd3 = (kd)b.get(j2);
        sn sn8 = kd3.a(sn5, flag, flag1, um1);
        if(k[j2] == null)
        {
            k[j2] = sn8;
            treeset.add(a.a(j2));
            if(!flag3)
                continue; /* Loop/switch isn't completed */
        }
        fv fv2 = new fv();
        sn sn10 = k[j2].a(um1, sn8, fv2);
        if(fv2.a())
        {
            k[j2] = sn10;
            treeset.add(a.a(j2));
        }
        i2++;
_L7:
        if(i2 < axm1.length) goto _L6; else goto _L5
_L5:
        Enumeration enumeration;
        boolean flag2;
        if(kd.k(k1))
        {
            md md1 = (md)kd2;
            td td3 = md1.q();
            int l2 = td3.a();
            sn sn2 = new sn(k[j1].c(), k[j1].f(), new e1(td3, d));
            sn sn4 = td3.a(sn2, flag, flag1, um1);
            if(k[l2] == null)
            {
                k[l2] = sn4;
                treeset1.add(a.a(l2));
                if(!flag3)
                    continue; /* Loop/switch isn't completed */
            }
            fv fv1 = new fv();
            sn sn6 = k[l2].a(um1, sn2, fv1);
            if(!fv1.a())
                continue; /* Loop/switch isn't completed */
            k[l2] = sn6;
            treeset1.add(a.a(l2));
            if(!flag3)
                continue; /* Loop/switch isn't completed */
        }
        if(!(kd2 instanceof le))
            continue; /* Loop/switch isn't completed */
        le le1 = (le)kd2;
        lx.b(o != null, p + " " + j1);
        enumeration = o.b(le1).keys();
        flag2 = false;
        if(!flag3) goto _L9; else goto _L8
_L8:
        Integer integer1;
label2:
        {
            integer1 = (Integer)enumeration.nextElement();
            int i3 = integer1.intValue();
            int j3 = i3 - 1;
            if(k[j3] == null)
            {
                bn bn1 = a(j3);
                if(hashset1 == null)
                    hashset1 = new HashSet(h);
                if(!hashset1.contains(bn1))
                    continue; /* Loop/switch isn't completed */
                e6_1.a(integer);
                flag2 = true;
                if(!flag3)
                    continue; /* Loop/switch isn't completed */
            }
            if(fy1.a(kd2, integer1))
                continue; /* Loop/switch isn't completed */
            sn sn7 = sn.a(um1, k[j1], k[j3].f(), k[j3].e());
            kd kd4 = (kd)b.get(i3);
            sn sn9 = kd4.a(sn7, flag, flag1, um1);
            fv fv3 = new fv();
            if(k[i3] == null)
            {
                k[i3] = sn9;
                treeset.add(integer1);
                if(!flag3)
                    break label2;
            }
            sn sn11 = k[i3].a(um1, sn9, fv3);
            if(fv3.a())
            {
                k[i3] = sn11;
                treeset.add(integer1);
            }
        }
        fy1.b(kd2, integer1, integer1);
_L9:
        if(enumeration.hasMoreElements()) goto _L8; else goto _L10
_L10:
        if(!flag2)
            continue; /* Loop/switch isn't completed */
        if(hashset == null)
            hashset = new HashSet();
        if(treeset.size() == 0)
        {
            Integer integer2 = new Integer(e6_1.hashCode());
            if(hashset.contains(integer2))
                throw new ub(z[27] + p + z[35]);
            hashset.add(integer2);
            if(!flag3)
                continue; /* Loop/switch isn't completed */
        }
        hashset.clear();
        if(!treeset.isEmpty() || !treeset1.isEmpty() || !e6_1.b()) goto _L12; else goto _L11
_L11:
    }

    private void a(int i1, int j1, TreeSet treeset, boolean flag, boolean flag1)
        throws ub, tb, sb
    {
label0:
        {
            kd kd1 = (kd)b.get(j1);
            sn sn1 = kd1.a(k[i1], flag, flag1, n);
            if(k[j1] == null)
            {
                k[j1] = sn1;
                treeset.add(a.a(j1));
                if(!wn.C)
                    break label0;
            }
            fv fv1 = new fv();
            sn sn2 = k[j1].a(n, sn1, fv1);
            if(fv1.a())
            {
                k[j1] = sn2;
                treeset.add(a.a(j1));
            }
        }
    }

    private boolean a(String s1, ArrayList arraylist)
        throws wb
    {
        int i1;
        boolean flag;
        flag = wn.C;
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        xm xm1 = (xm)arraylist.get(i1);
        if(s1.equals(xm1.e))
            return true;
        if(t.b(s1.substring(1, s1.length() - 1), xm1.e.substring(1, xm1.e.length() - 1)))
            return true;
        i1++;
_L2:
        if(i1 >= arraylist.size())
            return false;
        if(true) goto _L1; else goto _L3
_L3:
    }

    public void a()
    {
        int i1;
        boolean flag;
        flag = wn.C;
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn1 = (bn)h.elementAt(i1);
        bn1.a();
        i1++;
_L2:
        if(i1 >= h.size())
        {
            b = null;
            c = null;
            f = null;
            g.removeAllElements();
            g = null;
            h.removeAllElements();
            h = null;
            i.a();
            i = null;
            j = null;
            k = null;
            if(o != null)
                o.a();
            r = null;
            return;
        }
        if(true) goto _L1; else goto _L3
_L3:
    }

    int d()
    {
        int i1;
        int j1;
        boolean flag;
        flag = wn.C;
        i1 = 0x7fffffff;
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn1 = (bn)h.elementAt(j1);
        if(((kd)b.elementAt(bn1.d())).l())
        {
            int k1 = bn1.s();
            if(k1 < i1)
                i1 = k1;
        }
        j1++;
_L2:
        if(j1 >= h.size())
            return i1;
        if(true) goto _L1; else goto _L3
_L3:
    }

    Vector e()
    {
        int i1;
        Hashtable hashtable;
        HashMap hashmap;
        int j1;
        boolean flag;
        flag = wn.C;
        i1 = px.a(h.size());
        hashtable = new Hashtable(i1);
        Hashtable hashtable1 = new Hashtable(i1);
        hashtable.put(f, f);
        hashtable1.put(f, f);
        hashmap = new HashMap();
        f.a(hashmap, hashtable1, hashtable);
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn1 = (bn)g.elementAt(j1);
        if(!hashtable.containsKey(bn1))
        {
            Hashtable hashtable2 = new Hashtable(i1);
            hashtable.put(bn1, bn1);
            hashtable2.put(bn1, bn1);
            bn1.a(hashmap, hashtable2, hashtable);
        }
        j1++;
_L2:
        if(j1 < g.size()) goto _L1; else goto _L3
_L3:
        Vector vector;
        Iterator iterator;
        vector = new Vector();
        iterator = hashmap.values().iterator();
        if(!flag) goto _L5; else goto _L4
_L4:
        vector.add(iterator.next());
_L5:
        if(!iterator.hasNext())
            return vector;
        if(true) goto _L4; else goto _L6
_L6:
    }

    public List f()
    {
        return (Vector)h.clone();
    }

    wm g()
    {
        return new wm(this);
    }

    public int[] h()
    {
        ArrayList arraylist;
        int i1;
        int j1;
        boolean flag;
        flag = wn.C;
        arraylist = new ArrayList();
        i1 = b.size();
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        kd kd1 = (kd)b.get(j1);
        if(!(kd1 instanceof td) && k[j1] == null)
            arraylist.add(a.a(j1));
        j1++;
_L2:
        if(j1 < i1) goto _L1; else goto _L3
_L3:
        int ai[];
        int k1;
        ai = new int[arraylist.size()];
        k1 = 0;
        if(!flag) goto _L5; else goto _L4
_L4:
        ai[k1] = ((Integer)arraylist.get(k1)).intValue();
        k1++;
_L5:
        if(k1 >= ai.length)
            return ai;
        if(true) goto _L4; else goto _L6
_L6:
    }

    private xm[] a(int i1, xm axm[])
        throws wb
    {
        ArrayList arraylist;
        int j1;
        boolean flag;
        flag = wn.C;
        arraylist = new ArrayList();
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        xm xm1 = axm[j1];
        if(i1 < xm1.b || i1 >= xm1.c)
            continue; /* Loop/switch isn't completed */
        if(xm1.h)
        {
            arraylist.add(xm1);
            if(!flag)
                break; /* Loop/switch isn't completed */
        }
        if(!a(xm1.e, arraylist))
            arraylist.add(xm1);
        j1++;
_L2:
        if(j1 < axm.length) goto _L1; else goto _L3
_L3:
        xm axm1[] = new xm[arraylist.size()];
        return (xm[])arraylist.toArray(axm1);
    }

    public Vector j()
    {
        return l;
    }

    public bn a(int i1)
    {
        int j1;
        int k1;
        boolean flag1;
label0:
        {
            flag1 = wn.C;
            if(r == null)
            {
                r = new bn[q.r()];
                if(!flag1)
                    break label0;
            }
            if(r[i1] != null)
                return r[i1];
        }
        j1 = 0;
        k1 = h.size() - 1;
        boolean flag = false;
        if(!flag1) goto _L2; else goto _L1
_L1:
        int l1 = (j1 + k1) / 2;
        bn bn1 = (bn)h.elementAt(l1);
        if(i1 < bn1.m())
        {
            k1 = l1 - 1;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        if(i1 > bn1.d())
        {
            j1 = l1 + 1;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        r[i1] = bn1;
        return bn1;
_L2:
        if(j1 <= k1) goto _L1; else goto _L3
_L3:
        return null;
    }

    public bn b(int i1)
    {
        int j1;
        int k1;
        boolean flag1;
        flag1 = wn.C;
        j1 = 0;
        k1 = h.size() - 1;
        boolean flag = false;
        if(!flag1) goto _L2; else goto _L1
_L1:
        int l1 = (j1 + k1) / 2;
        bn bn1 = (bn)h.elementAt(l1);
        int i2 = bn1.m();
        if(i1 < i2)
        {
            k1 = l1 - 1;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        if(i1 > i2)
        {
            j1 = l1 + 1;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        return bn1;
_L2:
        if(j1 <= k1) goto _L1; else goto _L3
_L3:
        return null;
    }

    public int k()
    {
        return h.size();
    }

    ym l()
    {
        return new ym(this);
    }

    public int m()
    {
        return m;
    }

    public pu[] a(au au, lm lm, Vector vector)
        throws ub
    {
        Integer ainteger[];
        pu apu[];
        int i1;
        boolean flag;
        flag = wn.C;
        if(s)
            throw new ub("'" + p + z[0]);
        ainteger = a();
        apu = new pu[ainteger.length];
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        int j1 = ainteger[i1].intValue();
        td td1 = (td)b.get(j1);
        sn sn1 = k[j1];
        apu[i1] = new pu(au, td1, sn1, lm, vector);
        i1++;
_L2:
        if(i1 >= ainteger.length)
            return apu;
        if(true) goto _L1; else goto _L3
_L3:
    }

    private Integer[] a()
    {
        HashSet hashset;
        ArrayList arraylist;
        int i1;
        boolean flag;
        flag = wn.C;
        hashset = new HashSet(px.a(h.size()));
        arraylist = new ArrayList(h.size());
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn1 = (bn)g.get(i1);
        td td1 = (td)b.get(bn1.m());
        Integer integer = a.a(td1.q());
        if(hashset.add(integer))
            arraylist.add(a.a(td1.a()));
        i1++;
_L2:
        if(i1 < g.size()) goto _L1; else goto _L3
_L3:
        int j1 = 0;
        if(!flag) goto _L5; else goto _L4
_L4:
        Iterator iterator;
        bn bn2 = (bn)h.get(j1);
        kd kd1 = (kd)b.get(bn2.d());
        if(kd1 instanceof md)
        {
            td td2 = ((md)kd1).q();
            Integer integer1 = a.a(td2.q());
            if(!hashset.add(integer1))
                continue;
            arraylist.add(a.a(td2.a()));
            if(!flag)
                continue;
        }
        if(!(kd1 instanceof qd))
            continue;
        List list = ((qd)kd1).p();
        iterator = list.iterator();
        if(!flag) goto _L7; else goto _L6
_L6:
        td td3 = (td)iterator.next();
        Integer integer2 = a.a(td3.q());
        if(hashset.add(integer2))
            arraylist.add(a.a(td3.a()));
_L7:
        if(iterator.hasNext()) goto _L6; else goto _L8
_L8:
        j1++;
_L5:
        if(j1 >= h.size())
        {
            Integer ainteger[] = new Integer[arraylist.size()];
            arraylist.toArray(ainteger);
            Arrays.sort(ainteger);
            return ainteger;
        }
        if(true) goto _L4; else goto _L9
_L9:
    }

    public s6[] a(t6 t6, lm lm, Vector vector)
    {
        Integer ainteger[];
        s6 as6[];
        sx sx1;
        wu wu1;
        wu wu2;
        int i1;
        boolean flag;
        flag = wn.C;
        ainteger = a();
        as6 = new s6[ainteger.length];
        sx1 = new sx(-1);
        wu1 = new wu();
        wu2 = new wu();
        if(k.length > 0)
        {
            wu1.a(qu.a(s6.a(t6), k[0].f(), lm, vector, true));
            wu2.a(new qu[0]);
        }
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        int j1 = ainteger[i1].intValue();
        td td1 = (td)b.get(j1);
        sn sn1 = k[j1];
        as6[i1] = new s6(t6, td1, sn1, lm, vector, sx1, wu1, wu2);
        i1++;
_L2:
        if(i1 >= ainteger.length)
            return as6;
        if(true) goto _L1; else goto _L3
_L3:
    }

    public sn[] n()
    {
        return k;
    }

    public tn c(int i1)
    {
        if(k[i1] != null)
            return k[i1].d();
        else
            return null;
    }

    private ArrayList a(jy jy1)
        throws ub
    {
        ArrayList arraylist;
        fy fy1;
        int i1;
        boolean flag2;
        flag2 = wn.C;
        arraylist = new ArrayList(jy1.size());
        if(jy1.size() <= 1)
        {
            if(jy1.size() == 1)
                arraylist.add(jy1.a(0));
            return arraylist;
        }
        fy1 = new fy();
        i1 = 0;
        if(!flag2) goto _L2; else goto _L1
_L1:
        bn bn1 = (bn)jy1.a(i1);
        a(bn1, bn1, fy1, new HashSet(13), false);
        i1++;
_L2:
        if(i1 < jy1.size()) goto _L1; else goto _L3
_L3:
        HashMap hashmap;
        fy fy2;
        Enumeration enumeration;
        hashmap = new HashMap(Math.max(px.a(jy1.size()), 7));
        fy2 = (fy)fy1.clone();
        enumeration = fy2.d();
        if(!flag2) goto _L5; else goto _L4
_L4:
        bn bn2;
        Enumeration enumeration1;
        bn2 = (bn)enumeration.nextElement();
        Hashtable hashtable = fy2.b(bn2);
        enumeration1 = hashtable.keys();
        if(!flag2) goto _L7; else goto _L6
_L6:
        bn bn4 = (bn)enumeration1.nextElement();
        bn bn5 = (bn)hashmap.put(bn4, bn2);
        if(bn5 == null)
            continue; /* Loop/switch isn't completed */
        boolean flag = ((Boolean)fy2.b(bn2, bn4)).booleanValue();
        boolean flag1 = ((Boolean)fy2.b(bn5, bn4)).booleanValue();
        if(flag1 && !flag)
        {
            Boolean boolean1 = (Boolean)fy1.c(bn5, bn4);
            if(!flag2)
                continue; /* Loop/switch isn't completed */
        }
        if(!flag1 && flag)
        {
            hashmap.put(bn4, bn5);
            Boolean boolean2 = (Boolean)fy1.c(bn2, bn4);
            if(!flag2)
                continue; /* Loop/switch isn't completed */
        }
        if(flag1 && flag)
            throw new ub(z[27] + p + z[28]);
        if(!flag1 && !flag)
            lx.b(false, z[27] + p + z[29]);
_L7:
        if(enumeration1.hasMoreElements()) goto _L6; else goto _L5
_L5:
        if(enumeration.hasMoreElements()) goto _L4; else goto _L8
_L8:
        int j1 = 0;
        if(!flag2) goto _L10; else goto _L9
_L9:
        bn bn3 = (bn)jy1.a(j1);
        if(!hashmap.containsKey(bn3))
            a(bn3, fy1, arraylist);
        j1++;
_L10:
        if(j1 >= jy1.size())
            if(arraylist.size() != jy1.size())
                throw new ub(z[27] + p + z[26]);
            else
                return arraylist;
        if(true) goto _L9; else goto _L11
_L11:
    }

    private void a(bn bn1, bn bn2, fy fy1, HashSet hashset, boolean flag)
    {
        bn bn3;
        boolean flag1;
        flag1 = wn.C;
        if(hashset.contains(bn2))
            return;
        hashset.add(bn2);
        bn3 = bn2.l();
        if(bn3 == null) goto _L2; else goto _L1
_L1:
        md md1 = (md)b.elementAt(bn2.d());
        td td1 = md1.q();
        bn bn6 = b(td1.a());
        Boolean boolean1 = new Boolean(flag);
        if(bn1 != bn6)
        {
            Boolean boolean2 = (Boolean)fy1.b(bn1, bn6, boolean1);
            if(boolean2 != null && !boolean2.booleanValue() && boolean1.booleanValue())
                fy1.b(bn1, bn6, boolean2);
        }
        a(bn1, bn3, fy1, hashset, flag);
        if(!flag1) goto _L3; else goto _L2
_L2:
        Enumeration enumeration = bn2.q();
        if(enumeration == null) goto _L3; else goto _L4
_L4:
        if(!flag1) goto _L6; else goto _L5
_L5:
        bn bn4 = (bn)enumeration.nextElement();
        a(bn1, bn4, fy1, hashset, flag);
_L6:
        if(enumeration.hasMoreElements()) goto _L5; else goto _L3
_L3:
        enumeration = bn2.c();
        if(!flag1) goto _L8; else goto _L7
_L7:
        bn bn5 = (bn)enumeration.nextElement();
        a(bn1, bn5, fy1, hashset, true);
_L8:
        if(!enumeration.hasMoreElements())
            return;
        if(true) goto _L7; else goto _L9
_L9:
    }

    private zn a(zm zm1)
    {
        zn zn1;
        hn hn1;
        int i2;
        Iterator iterator;
        boolean flag1;
        flag1 = wn.C;
        zn1 = null;
        boolean flag = q.t().D();
        int i1 = -1;
        int j1 = b.size();
        for(int k1 = 0; k1 < j1; k1++)
        {
            kd kd1 = (kd)b.get(k1);
            if(kd1.f() != 176)
                continue;
            if(i1 == -1)
            {
                i1 = k1;
                if(!flag1)
                    continue;
            }
            zn1 = new zn(z[60], q);
        }

        if(zn1 != null)
            break MISSING_BLOCK_LABEL_683;
        if(i1 <= -1)
            break MISSING_BLOCK_LABEL_660;
        bn bn1 = a(i1);
        sn sn1 = k[i1];
        int l1 = sn1.g();
        HashSet hashset = new HashSet(13);
        zm zm2 = new zm(this, hashset, false, 3, zm1.d, zm1.e, zm1.f, zm1.g, zm1.h, zm1.i, flag, zm1.m, zm1.n, zm1.o, zm1.p, zm1.a() + 1, zm1.r);
        a(zm2, bn1, i1, l1);
        if(hashset.size() == 0)
        {
            zn1 = new zn(z[65], q);
            if(!flag1)
                break MISSING_BLOCK_LABEL_705;
        }
        if(hashset.size() == 1)
        {
            Object obj = hashset.iterator().next();
            if(obj instanceof jn)
            {
                jn jn1 = (jn)obj;
                if(q == jn1.g())
                {
                    zn1 = new zn(jn1.h(), q);
                    if(!flag1)
                        break MISSING_BLOCK_LABEL_705;
                }
                zn1 = new zn(z[64] + q.v() + z[62] + jn1.g().v(), q);
                if(!flag1)
                    break MISSING_BLOCK_LABEL_705;
            }
            if(obj instanceof un)
            {
                un un1 = (un)obj;
                zn1 = new zn(un1.g(), q);
                if(!flag1)
                    break MISSING_BLOCK_LABEL_705;
            }
            if(obj instanceof hn)
            {
                zn1 = new zn((hn)obj, q);
                if(!flag1)
                    break MISSING_BLOCK_LABEL_705;
            }
            if(obj instanceof yn)
            {
                yn yn1 = (yn)obj;
                zn1 = new zn(yn1.g(), q);
                if(!flag1)
                    break MISSING_BLOCK_LABEL_705;
            }
            if(obj instanceof mn)
            {
                mn mn1 = (mn)obj;
                zn1 = new zn(z[61] + mn1.h() + "'", q);
                if(!flag1)
                    break MISSING_BLOCK_LABEL_705;
            }
            zn1 = new zn(z[63], q);
            if(!flag1)
                break MISSING_BLOCK_LABEL_705;
        }
        hn1 = new hn(hashset.size());
        i2 = 0;
        iterator = hashset.iterator();
        if(!flag1) goto _L2; else goto _L1
_L1:
        kn kn1 = (kn)iterator.next();
        hn1.a(i2++, kn1);
_L2:
        if(iterator.hasNext()) goto _L1; else goto _L3
_L3:
        zn1 = new zn(hn1, q);
        if(!flag1)
            break MISSING_BLOCK_LABEL_705;
        zn1 = new zn(z[59], q);
        if(!flag1)
            break MISSING_BLOCK_LABEL_705;
        if(zn1 == null)
            zn1 = new zn(z[60], q);
        return zn1;
    }

    public boolean b()
    {
        return l != null && l.size() > 0;
    }

    private boolean a(ss ss1, yg yg)
    {
        try
        {
            if(ss1.s().equals(z[34]))
            {
                String s1 = ss1.b();
                return s1.equals(z[33]) || yg.a(s1, z[33]);
            } else
            {
                return false;
            }
        }
        catch(wb wb1)
        {
            return false;
        }
    }

    private boolean b(ss ss1, yg yg)
    {
        return a(ss1, z[22], yg);
    }

    private boolean a(ss ss1, String s1, yg yg)
    {
        try
        {
            if(ss1.s().equals(s1))
            {
                String s2 = ss1.b();
                return s2.equals(z[1]) || yg.a(s2, z[1]);
            } else
            {
                return false;
            }
        }
        catch(wb wb1)
        {
            return false;
        }
    }

    private boolean c(ss ss1, yg yg)
    {
        return a(ss1, z[58], yg);
    }

    private void a(bn bn1, Hashtable hashtable)
    {
        Enumeration enumeration;
        boolean flag;
        flag = wn.C;
        if(hashtable.containsKey(bn1))
            break MISSING_BLOCK_LABEL_79;
        hashtable.put(bn1, bn1);
        enumeration = bn1.q();
        if(enumeration == null) goto _L2; else goto _L1
_L1:
        if(!flag) goto _L4; else goto _L3
_L3:
        bn bn2 = (bn)enumeration.nextElement();
        a(bn2, hashtable);
_L4:
        if(enumeration.hasMoreElements()) goto _L3; else goto _L2
_L2:
        bn bn3 = bn1.l();
        if(bn3 != null)
            a(bn3, hashtable);
    }

    void a(fy fy1)
    {
        ArrayList arraylist;
        boolean flag2;
        flag2 = wn.C;
        if(h.size() == 1)
            return;
        arraylist = null;
        for(int i1 = 0; i1 < h.size(); i1++)
        {
            bn bn1 = (bn)h.elementAt(i1);
            if(bn1.h() == null)
            {
                if(arraylist == null)
                    arraylist = new ArrayList();
                arraylist.add(bn1);
            }
        }

        if(arraylist == null) goto _L2; else goto _L1
_L1:
        int j1 = 0;
        if(!flag2) goto _L4; else goto _L3
_L3:
        h.removeElement(arraylist.get(j1));
        j1++;
_L4:
        if(j1 < arraylist.size()) goto _L3; else goto _L2
_L2:
        Hashtable hashtable;
        e6 e6_1;
        int k1;
        hashtable = new Hashtable(px.a(h.size()));
        a(f, hashtable);
        e6_1 = new e6();
        k1 = 0;
        if(!flag2) goto _L6; else goto _L5
_L5:
        e6_1.a(g.get(k1));
        k1++;
_L6:
        if(k1 < g.size()) goto _L5; else goto _L7
_L7:
        boolean flag = true;
        if(!flag2) goto _L9; else goto _L8
_L8:
        int l1;
        int i2;
        int j2;
        l1 = e6_1.d();
        i2 = hashtable.size();
        j2 = 0;
        if(!flag2) goto _L11; else goto _L10
_L10:
        bn bn3;
        Hashtable hashtable1;
        boolean flag1;
        bn3 = (bn)e6_1.c();
        hashtable1 = fy1.b(bn3);
        flag1 = false;
        if(hashtable1 == null) goto _L13; else goto _L12
_L12:
        Enumeration enumeration = hashtable1.keys();
        if(!flag2) goto _L15; else goto _L14
_L14:
        bn bn4 = (bn)enumeration.nextElement();
        if(!hashtable.containsKey(bn4))
            continue; /* Loop/switch isn't completed */
        a(bn3, hashtable);
        flag1 = true;
        if(!flag2)
            break; /* Loop/switch isn't completed */
_L15:
        if(enumeration.hasMoreElements()) goto _L14; else goto _L13
_L13:
        if(!flag1)
            e6_1.a(bn3);
        j2++;
_L11:
        if(j2 < l1) goto _L10; else goto _L16
_L16:
        flag = i2 != hashtable.size();
_L9:
        if(e6_1.b()) goto _L18; else goto _L17
_L17:
        if(flag) goto _L8; else goto _L19
_L19:
        if(!flag2) goto _L18; else goto _L20
_L20:
        bn bn2 = (bn)e6_1.c();
        g.removeElement(bn2);
        i.e(bn2);
_L18:
        if(e6_1.b())
        {
            h.removeAllElements();
            h.addAll(hashtable.keySet());
            Collections.sort(h);
            return;
        }
        if(true) goto _L20; else goto _L21
_L21:
    }

    private void a(bn bn1, bn bn2, HashSet hashset)
    {
        Enumeration enumeration;
        boolean flag;
        flag = wn.C;
        if(hashset.contains(bn2))
            return;
        hashset.add(bn2);
        bn bn3 = bn2.l();
        if(bn3 != null)
        {
            a(bn1, bn3, hashset);
            if(!flag)
                break MISSING_BLOCK_LABEL_243;
        }
        enumeration = bn2.q();
        if(enumeration == null || !enumeration.hasMoreElements())
            break MISSING_BLOCK_LABEL_105;
        if(!flag) goto _L2; else goto _L1
_L1:
        bn bn4 = (bn)enumeration.nextElement();
        a(bn1, bn4, hashset);
_L2:
        if(enumeration.hasMoreElements()) goto _L1; else goto _L3
_L3:
        if(!flag)
            break MISSING_BLOCK_LABEL_243;
        le le1;
        Iterator iterator;
        kd kd1 = (kd)b.elementAt(bn2.d());
        if(!(kd1 instanceof le) || bn2.a() != null)
            break MISSING_BLOCK_LABEL_243;
        le1 = (le)kd1;
        iterator = bn1.f().iterator();
        if(!flag) goto _L5; else goto _L4
_L4:
        bn bn6 = (bn)iterator.next();
        if(o == null)
            o = new fy(13, 13);
        Integer integer = a.a(bn6.l().m());
        o.b(le1, integer, integer);
_L5:
        if(iterator.hasNext()) goto _L4; else goto _L6
_L6:
        bn2.g(bn1);
        bn1.e(bn2);
        enumeration = bn2.c();
        if(!flag) goto _L8; else goto _L7
_L7:
        bn bn5 = (bn)enumeration.nextElement();
        a(bn1, bn5, hashset);
_L8:
        if(!enumeration.hasMoreElements())
            return;
        if(true) goto _L7; else goto _L9
_L9:
    }

    private HashSet a(zm zm1, lu lu1, Vector vector)
    {
        HashSet hashset;
        boolean flag;
        int i1;
        boolean flag1;
        flag1 = wn.C;
        hashset = new HashSet(px.a(vector.size() + 2));
        flag = q.t().D();
        i1 = 0;
        if(!flag1) goto _L2; else goto _L1
_L1:
        int j1 = ((Integer)vector.get(i1)).intValue();
        kd kd1 = (kd)b.get(j1);
        bn bn1 = a(j1);
        if(k[j1] != null)
        {
            int k1 = k[j1].g();
            int l1 = k1 + (lu1.D() ? 0 : 1);
            zm zm2 = new zm(this, hashset, false, zm1.l, zm1.d, zm1.e, zm1.f, zm1.g, zm1.h, zm1.i, flag, zm1.m, zm1.n, zm1.o, zm1.p, zm1.a() + 1, zm1.r);
            a(zm2, bn1, j1, l1);
        }
        i1++;
_L2:
        if(i1 >= vector.size())
            return hashset;
        if(true) goto _L1; else goto _L3
_L3:
    }

    private void a(zm zm1, an an1, bn bn1, int i1)
    {
        vs vs1;
        qy qy2;
        Enumeration enumeration;
        boolean flag;
        flag = wn.C;
        zd zd1 = (zd)b.get(i1);
        vs1 = (vs)zd1.p();
        lu lu1 = (lu)vs1.o();
        if(lu1 == null)
            break MISSING_BLOCK_LABEL_418;
        po po = lu1.M();
        qy qy1 = zm1.e.b(po);
        if(qy1 == null)
            break MISSING_BLOCK_LABEL_457;
        if(qy1.c() != 1)
            break MISSING_BLOCK_LABEL_391;
        qy2 = zm1.d.b(po);
        if(qy2 == null)
            break MISSING_BLOCK_LABEL_457;
        enumeration = qy2.e();
        if(!flag) goto _L2; else goto _L1
_L1:
        du du1;
        Object obj;
        int j1;
        du1 = (du)enumeration.nextElement();
        if(du1 != q)
            break MISSING_BLOCK_LABEL_213;
        obj = qy2.d(du1);
        j1 = 0;
        if(!flag) goto _L4; else goto _L3
_L3:
        int k1 = ((Integer)((Vector) (obj)).get(j1)).intValue();
        sn sn1 = k[k1];
        if(sn1 != null)
            a(zm1, an1, a(k1), k1 + 1, sn1.c().length - 1);
        j1++;
_L4:
        if(j1 < ((Vector) (obj)).size()) goto _L3; else goto _L5
_L5:
        if(!flag)
            continue; /* Loop/switch isn't completed */
        Vector vector;
        int l1;
        obj = du1.a(zm1.r, zm1.g, t);
        vector = qy2.d(du1);
        l1 = 0;
        if(!flag) goto _L7; else goto _L6
_L6:
        int i2 = ((Integer)vector.get(l1)).intValue();
        sn sn2 = ((vm) (obj)).k[i2];
        if(sn2 != null)
        {
            an an2 = an1.a(((vm) (obj)));
            ((vm) (obj)).a(zm1, an2, ((vm) (obj)).a(i2), i2 + 1, sn2.c().length - 1);
        }
        l1++;
_L7:
        if(l1 < vector.size()) goto _L6; else goto _L8
_L8:
        continue; /* Loop/switch isn't completed */
        rb rb1;
        rb1;
        zm1.b.add(new yn(null, z[5] + rb1.getMessage()));
_L2:
        if(enumeration.hasMoreElements()) goto _L1; else goto _L9
_L9:
        if(!flag)
            break MISSING_BLOCK_LABEL_457;
        zm1.b.add(new yn(null, z[6]));
        if(!flag)
            break MISSING_BLOCK_LABEL_457;
        zm1.b.add(new yn(null, z[4] + vs1.h()));
    }

    private void a(zm zm1, an an1, bn bn1, int i1, int j1)
    {
        boolean flag;
        int k1;
        int l1;
        boolean flag1;
        flag1 = wn.C;
        if(an1.b(1, i1, j1))
            return;
        an1.a(1, i1, j1);
        flag = false;
        k1 = bn1.d();
        l1 = i1;
        if(!flag1) goto _L2; else goto _L1
_L1:
        kd kd1;
        sn sn1;
label0:
        {
            int ai[];
label1:
            {
                kd1 = (kd)b.get(l1);
                sn1 = k[l1];
                if(!kd1.m())
                    break label0;
                ai = kd1.d(sn1.g(), j1);
                if(ai.length == 0)
                {
                    flag = true;
                    if(!flag1)
                        break label1;
                }
                if(ai.length == 2)
                    a(zm1, an1, bn1, l1 + 1, ai[1]);
            }
            if(ai.length <= 0)
                continue; /* Loop/switch isn't completed */
            j1 = ai[0];
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        if(kd1.a(j1, sn1.c().length))
        {
            if(!an1.a(zm1, l1, bn1))
                switch(kd1.f())
                {
                default:
                    break;

                case 75: // 'K'
                    b(zm1, an1, bn1, l1 + 1, 0);
                    if(!flag1)
                        break;
                    // fall through

                case 76: // 'L'
                    b(zm1, an1, bn1, l1 + 1, 1);
                    if(!flag1)
                        break;
                    // fall through

                case 77: // 'M'
                    b(zm1, an1, bn1, l1 + 1, 2);
                    if(!flag1)
                        break;
                    // fall through

                case 78: // 'N'
                    b(zm1, an1, bn1, l1 + 1, 3);
                    if(!flag1)
                        break;
                    // fall through

                case 58: // ':'
                    vd vd1 = (vd)kd1;
                    b(zm1, an1, bn1, l1 + 1, vd1.a());
                    if(!flag1)
                        break;
                    // fall through

                case 179: 
                case 181: 
                    a(zm1, an1, bn1, l1);
                    break;
                }
            flag = true;
        }
        l1++;
_L2:
        if(!flag && l1 <= k1) goto _L1; else goto _L3
_L3:
        Vector vector;
        int i2;
        if(flag)
            break MISSING_BLOCK_LABEL_531;
        vector = bn1.j();
        if(vector == null || vector.size() <= 0)
            break MISSING_BLOCK_LABEL_451;
        i2 = 0;
        if(!flag1) goto _L5; else goto _L4
_L4:
        bn bn2 = (bn)vector.get(i2);
        a(zm1, an1, bn2, bn2.m(), j1);
        i2++;
_L5:
        if(i2 < vector.size()) goto _L4; else goto _L6
_L6:
        if(!flag1)
            break MISSING_BLOCK_LABEL_531;
        Object obj;
        int j2;
        if(!bn1.n())
            break MISSING_BLOCK_LABEL_517;
        obj = bn1.k();
        j2 = 0;
        if(!flag1) goto _L8; else goto _L7
_L7:
        bn bn3 = (bn)((ArrayList) (obj)).get(j2);
        a(zm1, an1, bn3, bn3.m(), j1);
        j2++;
_L8:
        if(j2 < ((ArrayList) (obj)).size()) goto _L7; else goto _L9
_L9:
        if(!flag1)
            break MISSING_BLOCK_LABEL_531;
        obj = (kd)b.get(k1);
    }

    private void a(ArrayList arraylist, bn bn1, int i1, int j1, HashSet hashset)
    {
        boolean flag;
        int k1;
        int l1;
        boolean flag1;
        flag1 = wn.C;
        if(hashset.contains(bn1))
            return;
        hashset.add(bn1);
        flag = false;
        k1 = bn1.m();
        l1 = i1 - 1;
        if(!flag1) goto _L2; else goto _L1
_L1:
label0:
        {
            kd kd1 = (kd)b.get(l1);
            sn sn1 = k[l1];
            if(kd1.m())
            {
                j1 = kd1.b(sn1.g(), j1);
                if(!flag1)
                    continue; /* Loop/switch isn't completed */
            }
            if(sn1.g() - 1 != j1 || !kd1.o())
                continue; /* Loop/switch isn't completed */
            switch(kd1.f())
            {
            case 3: // '\003'
                arraylist.add(a.a(0));
                if(!flag1)
                    break label0;
                // fall through

            case 4: // '\004'
                arraylist.add(a.a(1));
                if(!flag1)
                    break label0;
                // fall through

            case 5: // '\005'
                arraylist.add(a.a(2));
                if(!flag1)
                    break label0;
                // fall through

            case 6: // '\006'
                arraylist.add(a.a(3));
                if(!flag1)
                    break label0;
                // fall through

            case 7: // '\007'
                arraylist.add(a.a(4));
                if(!flag1)
                    break label0;
                // fall through

            case 8: // '\b'
                arraylist.add(a.a(5));
                if(!flag1)
                    break label0;
                // fall through

            case 16: // '\020'
                ld ld1 = (ld)kd1;
                arraylist.add(a.a(ld1.a()));
                if(!flag1)
                    break label0;
                // fall through

            case 9: // '\t'
            case 10: // '\n'
            case 11: // '\013'
            case 12: // '\f'
            case 13: // '\r'
            case 14: // '\016'
            case 15: // '\017'
            default:
                arraylist.add(z[25] + kd1.e());
                break;
            }
        }
        flag = true;
        l1--;
_L2:
        if(!flag && l1 >= k1) goto _L1; else goto _L3
_L3:
        Vector vector;
        int i2;
        if(flag)
            break MISSING_BLOCK_LABEL_456;
        vector = bn1.g();
        if(vector == null || vector.size() <= 0)
            break MISSING_BLOCK_LABEL_445;
        i2 = 0;
        if(!flag1) goto _L5; else goto _L4
_L4:
        bn bn2 = (bn)vector.get(i2);
        a(arraylist, bn2, bn2.d() + 1, j1, hashset);
        i2++;
_L5:
        if(i2 < vector.size()) goto _L4; else goto _L6
_L6:
        if(!flag1)
            break MISSING_BLOCK_LABEL_456;
        arraylist.add(z[55]);
    }

    void a(zm zm1, bn bn1, int i1, int j1)
    {
        py py1;
        HashSet hashset2;
        boolean flag;
        int k1;
        int l1;
        boolean flag1;
        flag1 = wn.C;
        py1 = new py(q, a.a(i1), a.a(j1));
        HashSet hashset = (HashSet)zm1.o.get(py1);
        if(hashset != null && zm1.l != 3 && zm1.l != 4)
        {
            zm1.b.addAll(hashset);
            if(!flag1)
                break MISSING_BLOCK_LABEL_1023;
        }
        hashset = new HashSet(13);
        hashset2 = zm1.a(hashset);
        if(zm1.a() > 3)
        {
            zm1.b.add(new yn(null, z[24] + zm1.a() + " " + zm1.l));
            if(!flag1)
                break MISSING_BLOCK_LABEL_962;
        }
        flag = false;
        k1 = bn1.m();
        l1 = i1 - 1;
        if(!flag1) goto _L2; else goto _L1
_L1:
        kd kd1 = (kd)b.get(l1);
        sn sn1 = k[l1];
        if(kd1.m())
        {
            j1 = kd1.b(sn1.g(), j1);
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        if(sn1.g() - 1 == j1)
        {
label0:
            {
                if(!kd1.o())
                    continue; /* Loop/switch isn't completed */
                switch(kd1.f())
                {
                case 18: // '\022'
                    ud ud1 = (ud)kd1;
                    is is1 = ud1.a();
                    if(is1 instanceof ys)
                    {
                        zm1.b.add(new un((ys)is1));
                        if(!flag1)
                            break label0;
                    }
                    if(!(is1 instanceof ks))
                        break label0;
                    zm1.b.add(new i5((ks)is1));
                    if(!flag1)
                        break label0;
                    // fall through

                case 19: // '\023'
                    zd zd1 = (zd)kd1;
                    is is2 = zd1.p();
                    if(is2 instanceof ys)
                    {
                        zm1.b.add(new un((ys)is2));
                        if(!flag1)
                            break label0;
                    }
                    if(!(is2 instanceof ks))
                        break label0;
                    zm1.b.add(new i5((ks)is2));
                    if(!flag1)
                        break label0;
                    // fall through

                case 42: // '*'
                    b(zm1, bn1, l1, 0);
                    if(!flag1)
                        break label0;
                    // fall through

                case 43: // '+'
                    b(zm1, bn1, l1, 1);
                    if(!flag1)
                        break label0;
                    // fall through

                case 44: // ','
                    b(zm1, bn1, l1, 2);
                    if(!flag1)
                        break label0;
                    // fall through

                case 45: // '-'
                    b(zm1, bn1, l1, 3);
                    if(!flag1)
                        break label0;
                    // fall through

                case 25: // '\031'
                    vd vd1 = (vd)kd1;
                    b(zm1, bn1, l1, vd1.a());
                    if(!flag1)
                        break label0;
                    // fall through

                case 182: 
                case 183: 
                case 184: 
                case 185: 
                    c(zm1, bn1, l1);
                    if(!flag1)
                        break label0;
                    // fall through

                case 178: 
                case 180: 
                    b(zm1, bn1, l1);
                    if(!flag1)
                        break label0;
                    // fall through

                case 189: 
                    a(zm1, bn1, l1);
                    if(!flag1)
                        break label0;
                    // fall through

                case 187: 
                    d(zm1, bn1, l1);
                    if(!flag1)
                        break label0;
                    // fall through

                case 1: // '\001'
                    zm1.b.add(new ln());
                    if(!flag1)
                        break label0;
                    // fall through

                default:
                    zm1.b.add(new yn(kd1, z[25] + zm1.l));
                    break;
                }
            }
            flag = true;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        if(kd.k(kd1.f()))
        {
            zm1.b.add(new yn(kd1, z[25] + zm1.l));
            flag = true;
        }
        l1--;
_L2:
        if(!flag && l1 >= k1) goto _L1; else goto _L3
_L3:
        Vector vector;
        int i2;
        if(flag)
            break MISSING_BLOCK_LABEL_962;
        vector = bn1.g();
        if(vector == null || vector.size() <= 0)
            break MISSING_BLOCK_LABEL_908;
        i2 = 0;
        if(!flag1) goto _L5; else goto _L4
_L4:
        bn bn2 = (bn)vector.get(i2);
        a(zm1, bn2, bn2.d() + 1, j1);
        i2++;
_L5:
        if(i2 < vector.size()) goto _L4; else goto _L6
_L6:
        if(!flag1)
            break MISSING_BLOCK_LABEL_962;
        kd kd2 = (kd)b.get(k1);
        zm1.b.add(new yn(kd2, z[23] + zm1.l));
        HashSet hashset1 = zm1.a(hashset2);
        hashset2.addAll(hashset1);
        if(zm1.l != 3 && zm1.l != 4)
        {
            HashSet hashset3 = (HashSet)zm1.o.put(py1, hashset1);
            if(hashset3 != null)
                hashset1.addAll(hashset3);
        }
    }

    void b(zm zm1, bn bn1, int i1, int j1)
    {
        py py1;
        int k1;
        boolean flag;
        HashSet hashset2;
        int l1;
        boolean flag1;
        flag1 = wn.C;
        py1 = new py(q, a.a(i1), a.a(j1));
        HashSet hashset = (HashSet)zm1.p.get(py1);
        k1 = bn1.m();
        if(hashset != null && i1 - 1 >= k1 && zm1.l != 3 && zm1.l != 4)
        {
            zm1.b.addAll(hashset);
            if(!flag1)
                break MISSING_BLOCK_LABEL_837;
        }
        flag = false;
        hashset = new HashSet(13);
        hashset2 = zm1.a(hashset);
        l1 = i1 - 1;
        if(!flag1) goto _L2; else goto _L1
_L1:
        sn sn1;
        Vector vector1;
        int k2;
        kd kd1 = (kd)b.get(l1);
        sn1 = k[l1];
        if(!kd1.b(j1))
            continue; /* Loop/switch isn't completed */
        if(l1 > k1)
        {
            a(zm1, bn1, l1, sn1.g());
            flag = true;
            if(!flag1)
                break; /* Loop/switch isn't completed */
        }
        vector1 = bn1.g();
        if(vector1 == null || vector1.size() <= 0)
            continue; /* Loop/switch isn't completed */
        k2 = 0;
        if(!flag1) goto _L4; else goto _L3
_L3:
        bn bn3 = (bn)vector1.get(k2);
        a(zm1, bn3, bn3.d() + 1, sn1.g());
        k2++;
_L4:
        if(k2 < vector1.size()) goto _L3; else goto _L5
_L5:
        flag = true;
        if(!flag1)
            break; /* Loop/switch isn't completed */
        l1--;
_L2:
        if(l1 >= k1) goto _L1; else goto _L6
_L6:
        Vector vector;
        int i2;
        if(flag)
            break MISSING_BLOCK_LABEL_760;
        vector = bn1.g();
        if(vector == null || vector.size() <= 0)
            break MISSING_BLOCK_LABEL_357;
        i2 = 0;
        if(!flag1) goto _L8; else goto _L7
_L7:
        bn bn2 = (bn)vector.get(i2);
        b(zm1, bn2, bn2.d() + 1, j1);
        i2++;
_L8:
        if(i2 < vector.size()) goto _L7; else goto _L9
_L9:
        if(!flag1)
            break MISSING_BLOCK_LABEL_760;
label0:
        {
            int j2;
label1:
            {
                if(bn1.o())
                {
                    e(zm1, bn1, j1);
                    if(!flag1)
                        break MISSING_BLOCK_LABEL_760;
                }
                if(!bn1.p())
                    break label0;
                if(zm1.j)
                {
                    j2 = j1;
                    if(!flag1)
                        break label1;
                }
                j2 = j1 - 1;
            }
            if(j2 < 0)
            {
                zm1.b.add(new yn((kd)b.get(k1), z[53] + p));
                if(!flag1)
                    break MISSING_BLOCK_LABEL_760;
            }
            if(j2 < e)
                switch(zm1.l)
                {
                default:
                    break MISSING_BLOCK_LABEL_760;

                case 1: // '\001'
                    a(zm1, j2);
                    if(!flag1)
                        break MISSING_BLOCK_LABEL_760;
                    // fall through

                case 2: // '\002'
                case 3: // '\003'
                    zm1.b.add(new yn((kd)b.get(k1), z[52] + zm1.l));
                    if(!flag1)
                        break MISSING_BLOCK_LABEL_760;
                    // fall through

                case 4: // '\004'
                    zm1.b.add(new jn(j2, q));
                    if(!flag1)
                        break MISSING_BLOCK_LABEL_760;
                    break;
                }
            zm1.b.add(String.valueOf(new yn((kd)b.get(k1), z[51] + j2 + " " + e + " " + zm1.l)) + " " + p);
            if(!flag1)
                break MISSING_BLOCK_LABEL_760;
        }
        kd kd2 = (kd)b.get(k1);
        zm1.b.add(new yn(kd2, z[54] + zm1.l));
        HashSet hashset1 = zm1.a(hashset2);
        hashset2.addAll(hashset1);
        if(i1 - 1 >= k1 && zm1.l != 3 && zm1.l != 4)
        {
            HashSet hashset3 = (HashSet)zm1.p.put(py1, hashset1);
            if(hashset3 != null && hashset3.size() > 0)
                hashset1.addAll(hashset3);
        }
    }

    private void a(zm zm1, int i1)
    {
        ou ou1;
        int j1;
        lp lp;
        qy qy1;
        boolean flag;
        flag = wn.C;
        ou1 = q.t();
        j1 = ou1.cb();
        lp = ou1.P();
        if(!zm1.a(lp))
            return;
        qy1 = zm1.f.b(lp);
        if(qy1 == null) goto _L2; else goto _L1
_L1:
        Enumeration enumeration = qy1.e();
        if(!flag) goto _L4; else goto _L3
_L3:
        du du1 = (du)enumeration.nextElement();
        vm vm1;
        Vector vector;
        int k1;
        vm1 = du1.a(zm1.r, zm1.g, t);
        vector = qy1.d(du1);
        k1 = 0;
        if(!flag) goto _L6; else goto _L5
_L5:
        int l1 = ((Integer)vector.get(k1)).intValue();
        sn sn1 = vm1.k[l1];
        if(sn1 != null)
        {
            int i2 = sn1.g();
            int j2 = i2 + j1 + ou1.d(i1);
            zm zm2 = new zm(this, zm1, du1.t().D());
            bn bn1 = vm1.a(l1);
            vm1.a(zm2, bn1, l1, j2);
        }
        k1++;
_L6:
        if(k1 < vector.size()) goto _L5; else goto _L7
_L7:
        continue; /* Loop/switch isn't completed */
        rb rb1;
        rb1;
        zm1.b.add(new yn(null, z[13] + rb1.getMessage() + z[38] + du1.j()));
_L4:
        if(enumeration.hasMoreElements()) goto _L3; else goto _L2
_L2:
        zm1.b(lp);
        return;
    }

    private void e(zm zm1, bn bn1, int i1)
    {
        HashSet hashset;
        Vector vector;
        int j1;
        boolean flag;
        flag = wn.C;
        hashset = new HashSet();
        vector = i.d(bn1);
        j1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        int k1;
        int l1;
        bn bn3;
        HashSet hashset1;
        int i2;
        xm xm1 = (xm)vector.get(j1);
        eu eu1 = xm1.i;
        td td1 = eu1.b(0);
        td td2 = eu1.b(1);
        k1 = td1.a();
        l1 = td2.a();
        bn3 = null;
        hashset1 = new HashSet();
        Iterator iterator1 = h.iterator();
        while(iterator1.hasNext()) 
        {
            bn bn4 = (bn)iterator1.next();
            if(bn4.m() >= k1 && bn4.m() < l1)
            {
                hashset1.add(bn4);
                if(!flag)
                    continue;
            }
            if(bn4.m() < k1 && bn4.d() >= k1)
                bn3 = bn4;
        }
        i2 = k1;
        if(!flag) goto _L4; else goto _L3
_L3:
        Vector vector1;
        int k2;
        kd kd1 = (kd)b.get(i2);
        if(!kd1.b(i1))
            continue; /* Loop/switch isn't completed */
        bn bn5 = a(i2);
        if(i2 > bn5.m())
        {
            a(zm1, bn5, i2, k[i2].g());
            return;
        }
        vector1 = bn5.g();
        if(vector1 == null || vector1.size() <= 0)
            continue; /* Loop/switch isn't completed */
        k2 = 0;
        if(!flag) goto _L6; else goto _L5
_L5:
        bn bn7 = (bn)vector1.get(k2);
        a(zm1, bn7, bn7.d() + 1, k[i2].g());
        k2++;
_L6:
        if(k2 < vector1.size()) goto _L5; else goto _L7
_L7:
        return;
        i2++;
_L4:
        if(i2 < l1) goto _L3; else goto _L8
_L8:
        Iterator iterator2;
label0:
        {
            if(bn3 == null)
                break label0;
            if(bn1 != bn3 && !bn1.a(bn3))
            {
                b(zm1, bn3, k1, i1);
                if(!flag)
                    break label0;
            }
            zm1.b.add(new yn((kd)b.get(bn1.m()), z[30]));
        }
        iterator2 = hashset1.iterator();
        if(!flag) goto _L10; else goto _L9
_L9:
        Vector vector2;
        int l2;
        bn bn6 = (bn)iterator2.next();
        int j2 = bn6.m();
        if(((kd)b.get(j2)).b(i1) || sn.g(k[j2].f()[i1]))
            continue; /* Loop/switch isn't completed */
        vector2 = bn6.g();
        if(vector2 == null || vector2.size() <= 0)
            continue; /* Loop/switch isn't completed */
        l2 = 0;
        if(!flag) goto _L12; else goto _L11
_L11:
        bn bn8 = (bn)vector2.get(l2);
        if(!hashset1.contains(bn8) && (bn3 == null || bn8 != bn3))
            hashset.add(bn8);
        l2++;
_L12:
        if(l2 < vector2.size()) goto _L11; else goto _L10
_L10:
        if(iterator2.hasNext()) goto _L9; else goto _L13
_L13:
        j1++;
_L2:
        if(j1 < vector.size()) goto _L1; else goto _L14
_L14:
        Iterator iterator = hashset.iterator();
        if(!flag) goto _L16; else goto _L15
_L15:
        bn bn2 = (bn)iterator.next();
        if(bn1 != bn2 && !bn1.a(bn2))
        {
            b(zm1, bn2, bn2.d() + 1, i1);
            if(!flag)
                continue; /* Loop/switch isn't completed */
        }
        zm1.b.add(new yn((kd)b.get(bn1.m()), z[30]));
_L16:
        if(iterator.hasNext()) goto _L15; else goto _L17
_L17:
    }

    private void b(zm zm1, an an1, bn bn1, int i1, int j1)
    {
        int k1;
        int l1;
        boolean flag;
        flag = wn.C;
        if(an1.b(2, i1, j1))
            return;
        an1.a(2, i1, j1);
        k1 = bn1.d();
        l1 = i1;
        if(!flag) goto _L2; else goto _L1
_L1:
        kd kd1 = (kd)b.get(l1);
        sn sn1 = k[l1];
        if(kd1.b(j1))
            return;
        if(kd1.a(j1))
        {
            int j2 = sn1.c().length - 1;
            a(zm1, an1, bn1, l1 + 1, j2);
        }
        l1++;
_L2:
        if(l1 < k1) goto _L1; else goto _L3
_L3:
        Vector vector = bn1.j();
        if(vector == null || vector.size() <= 0) goto _L5; else goto _L4
_L4:
        int i2 = 0;
        if(!flag) goto _L7; else goto _L6
_L6:
        bn bn2 = (bn)vector.get(i2);
        b(zm1, an1, bn2, bn2.m(), j1);
        i2++;
_L7:
        if(i2 < vector.size()) goto _L6; else goto _L8
_L8:
        if(!flag) goto _L9; else goto _L5
_L5:
        if(!bn1.n()) goto _L9; else goto _L10
_L10:
        ArrayList arraylist;
        int k2;
        arraylist = bn1.k();
        k2 = 0;
        if(!flag) goto _L12; else goto _L11
_L11:
        bn bn3 = (bn)arraylist.get(k2);
        b(zm1, an1, bn3, bn3.m(), j1);
        k2++;
_L12:
        if(k2 < arraylist.size()) goto _L11; else goto _L9
_L9:
    }

    private static String z(char ac[]) {
        for (int i = 0; i < ac.length; i++) {
            byte key = 0;
            switch (i % 5) {
                case 0:
                    key =0x59;
                    break;
                case 1:
                    key =82;
                    break;
                case 2:
                    key =105;
                    break;
                case 3:
                    key =83;
                    break;
                default:
                    key =55;
                    break;
            }
            ac[i] ^= key;
        }
        return new String(ac).intern();
    }

    static 
    {
        String as[];
        as = new String[66];
        as[0] = "~r\007<Cy3\005!R86\020sG+7\0376E04\0006S";
        as[1] = "33\0372\030,&\000?\030\t \006#R+&\0006D";
        as[2] = "\032=\034?S7u\035sS<&\f!Z0<\fsG+=\0316E-+I5^57I=V47";
        as[3] = "\027\027>s^7!\035!B:&\000<Yy<\006'\02713\0077[<6I$^-:Ii\027";
        as[4] = "\037;\f?Sy;\032sR!&\f!Y8>Ii\027";
        as[5] = "\034 \033<Ey%\001:[<r\035!V:;\0074\027?;\f?Sy'\0326\027cr";
        as[6] = "\037;\f?Sy!\f'\0274=\0336\027-:\b=\0276<\n6";
        as[7] = "33\0372\03053\0074\030\033=\006?R8<";
        as[8] = "\r\0139\026";
        as[9] = "33\0372\03053\0074\030\025=\0074";
        as[10] = "\n=\034!T<r\017:R56I:Dy7\021'R+<\b?\ry";
        as[11] = "33\0372\03053\0074\030\033+\0356";
        as[12] = "33\0372\03053\0074\030\037>\0062C";
        as[13] = "\034*\n6G-;\006=\027~";
        as[14] = "33\0372\03053\0074\030\020<\0356P< ";
        as[15] = "33\0372\03053\0074\030\n:\006!C";
        as[16] = "33\0372\03053\0074\030\017=\0007";
        as[17] = "33\0372\03053\0074\030\035=\0341[<";
        as[18] = "33\0372\03053\0074\030\032:\b!V:&\f!";
        as[19] = "7=\r6";
        as[20] = "17\b7R+";
        as[21] = ":3\0350_\027=\r6";
        as[22] = ">7\035\003E6\"\f!C z%9V/3F?V75F\000C+;\0074\fp\036\0032A8}\0052Y>}:'E0<\016h";
        as[23] = "\027=I X, \n6\027?=\034=Syc@i";
        as[24] = "\0243\021sy<!\035:Y>r%6A<>I\026O:7\f7R=hI";
        as[25] = "\020<\032'E,1\035:X7r\007<Cy:\b=S57\ri\027";
        as[26] = "~r\n<B56I=X-r\0136\0278<\b?N#7\rs\037\034{Gsy6r\b0C0=\007sE<#\034:E<6G";
        as[27] = "\0247\035;X=rN";
        as[28] = "~r\n<B56I=X-r\0136\0278<\b?N#7\rs\037\032{Gsy6r\b0C0=\007sE<#\034:E<6G";
        as[29] = "~r\n<B56I=X-r\0136\0278<\b?N#7\rs\037\035{";
        as[30] = "\025=\006#\027-:\033<B>:I0V-1\001";
        as[31] = "\020<\032'E,1\035:X7r\007<Cy:\b=S57\rs\006prSs";
        as[32] = "\020<\032'E,1\035:X7r\007<Cy:\b=S57\rs\005prSs";
        as[33] = "33\0372\03053\0074\030\032>\b D";
        as[34] = ">7\035\020X4\"\006=R7&=*G<z@\037]8$\b|[8<\016|t53\032 \f";
        as[35] = "~r\n<B56I=X-r\0136\0278<\b?N#7\rs\037\033{Gsg57\b Ry \f#X+&I'_0!I>R*!\b4Ry&\006sU,5\032\023M<>\000+\031:=\004}";
        as[36] = "~r\n<B56I=X-r\0136\0278<\b?N#7\rs\037\030{Gsy6r\b0C0=\007sE<#\034:E<6G";
        as[37] = "~r\n2[5";
        as[38] = "~rSs";
        as[39] = "y;\007s";
        as[40] = "33\0372\03053\0074\030\0260\0036T-";
        as[41] = "\0247\035;X=r\0362Dy3\013 C+3\n'\0276 I:Yy3\007s^7&\f!Q81\fi\027";
        as[42] = "\0247\035;X=r\n2[5r\007<Cy;\007'R+<\b?\ry";
        as[43] = "\t=\032 ^;>\fs\025>7\035\003E6\"\f!C pI0V5>I?X6\"";
        as[44] = "\0247\035;X=r92E8?\f'R+rSs";
        as[45] = "yhI";
        as[46] = "\n=\034!T<r\000 \02747\035;X=hI";
        as[47] = "\0247\035;X=r\n2[5r\007<Cy:\b=S57\ri\027";
        as[48] = "\f<\002=X.<I<U37\n'\027?=\033s\020";
        as[49] = "\024'\005'^)>\fsD6'\0330R*rSs";
        as[50] = ">7\035\020[8!\032{\036\0258\b%Vv>\b=Pv\021\0052D*i";
        as[51] = "\0173\033:V;>\fsb7;\007:C03\005:M<6Ii\027";
        as[52] = "\n=\034!T<r\000 \02747\035;X=r\0312E8?\f'R+hI";
        as[53] = "\n=\034!T<r\0061]<1\035sE<4\f!R71\fs\ry";
        as[54] = "\027=I X, \n6\027?=\034=Sy`@s\ry";
        as[55] = "\027=I%V5'\fsQ6'\0077";
        as[56] = "\030<\b?N*;\032sY6&I*R-r\000>G57\0046Y-7\r";
        as[57] = "\030\"\0316V+!I:Yy\026,\022sy1\0067Rwr*2Yy0\fs^><\006!R=|";
        as[58] = ">7\035\003E6\"\f!C z%9V/3F?V75F\000C+;\0074\f\0258\b%Vv>\b=Pv\001\035!^75Rz{33\0372\03053\0074\030\n&\033:Y>i";
        as[59] = "\027=I\022e\034\006<\001y";
        as[60] = "\024'\005'^)>\fsv\013\027=\006e\027!";
        as[61] = "\t7\0077^75It";
        as[62] = "y1\b?[*r";
        as[63] = "\f\034,\013g\034\021=\026sy\034(\036ry\001&\006e\032\027";
        as[64] = "\027\027:\007~\027\025I\007x\026r-\026r\t|I";
        as[65] = "\027=I X, \n6\027?=\034=S";
        for (int i = 0; i < as.length; i++) {
            as[i] = z(as[i].toCharArray());
        }
        z = as;
        a = it.n;
    }
}